package org.ithink.util;

import java.util.ArrayList;
import java.util.List;

public class StringUtils {

  /**
   * 去掉给定字符串前和后的空格，返回干净的字符串
   */
  public static String removeSpaces(String args) {

    if (args != null) {
      args = args.trim();
      while (args.startsWith(" ")) {
        args = args.substring(1, args.length()).trim();
      }
      while (args.endsWith(" ")) {
        args = args.substring(0, args.length() - 1).trim();
      }
    } else {
      args = "";
    }

    return args;
  }

  /**
   * 转全角的函数
   */
  public static String toSBC(String input) {
    // 半角转全角：
    char[] c = input.toCharArray();
    for (int i = 0; i < c.length; i++) {
      if (c[i] == 32) {
        c[i] = (char) 12288;
        continue;
      }
      if (c[i] < 127) {
        c[i] = (char) (c[i] + 65248);
      }
    }
    return new String(c);
  }

  /**
   * 转半角的函数
   */
  public static String toDBC(String input) {
    char[] c = input.toCharArray();
    for (int i = 0; i < c.length; i++) {
      if (c[i] == 12288) {
        c[i] = (char) 32;
        continue;
      }
      if (c[i] > 65280 && c[i] < 65375) {
        c[i] = (char) (c[i] - 65248);
      }
    }
    return new String(c);
  }

  /**
   * 为每添加一个元素前面增加指定的分隔 除第一个元素之外
   */
  public static StringBuffer appendElement(StringBuffer strB, String appStr, String compart) {

    // 当出入参数为NULL时
    if (strB == null) {
      return new StringBuffer(appStr);
    }

    // 当没有元素时直接添加追加元素 否则先添加分隔符
    if (strB.length() == 0) {
      strB.append(appStr);
    } else {
      strB.append(compart);
      strB.append(appStr);
    }

    return strB;
  }

  /**
   * 移除元素
   */
  public static StringBuffer moveElement(StringBuffer strB, String moveStr, String compart) {

    // 当出入参数为NULL时
    if (strB == null) {
      return strB;
    }

    StringBuffer newStrB = new StringBuffer();

    String[] strArray = strB.toString().split(compart);
    for (int i = 0; i < strArray.length; i++) {

      if (moveStr.equals(strArray[i])) {
        continue;
      }

      if (i == 0) {
        newStrB.append(strArray[i]);
      } else {
        newStrB.append(compart);
        newStrB.append(strArray[i]);
      }
    }

    return newStrB;
  }

  /**
   * 移除第一个匹配的元素
   */
  public static StringBuffer moveFirstElement(StringBuffer strB, String moveStr, String compart) {

    // 当出入参数为NULL时
    if (strB == null) {
      return strB;
    }

    StringBuffer newStrB = new StringBuffer();

    String[] strArray = strB.toString().split(compart);
    boolean tag = false;
    for (int i = 0; i < strArray.length; i++) {

      if (moveStr.equals(strArray[i]) == true && tag == false) {
        tag = true;
        continue;
      }

      if (i == 0) {
        newStrB.append(strArray[i]);
      } else {
        newStrB.append(compart);
        newStrB.append(strArray[i]);
      }
    }

    return newStrB;
  }

  /**
   * 从给定字符中 返回所含的中文字符 并按每组以以字符串数组的形式返回
   */
  public static String[] getChinese(String src) {

    List list = new ArrayList();

    byte[] srcByte = src.getBytes();
    int srcLength = srcByte.length;

    int begin = -1;
    int end = -1;

    for (int i = 0; i < srcLength; i++) {

      // 设置中文的开始位
      if (srcByte[i] < 0 && begin == -1) {
        begin = i;
      }

      // 设置中文的结束位
      if (srcByte[i] > 0 && begin != -1 && end == -1) {
        end = i;
      }

      // 如果已经找到中文的开始 但直到最后也没找到中文的结束，则将字符的结束位当成中文的截止位
      if (begin != -1 && i == srcLength - 1) {
        end = i;
      }

      // 将中文提取出来
      if (begin != -1 && end != -1) {

        int tempLength = end - begin + 1;
        if (tempLength % 2 != 0) {
          tempLength = tempLength - 1;
        }

        byte[] tempByte = new byte[tempLength];
        System.arraycopy(srcByte, begin, tempByte, 0, tempLength);

        list.add(new String(tempByte));

        begin = -1;
        end = -1;
      }

    }

    // 将中文以数组输出
    int size = list.size();
    String[] chineseArray = new String[size];
    for (int i = 0; i < size; i++) {
      chineseArray[i] = list.get(i).toString();
    }

    return chineseArray;
  }

  public static String zeroleft(String str, Integer len) {
    if (str == null || str.trim().length() < 1)
      str = "1";
    while (str.length() < len) {
      str = "0" + str;
    }
    return str;
  }

  /**
   * 前（填充位置，适用于本类方法fill）
   */
  private static final int FRONT = 10;

  /**
   * 后（填充位置，适用于本类方法fill）
   */
  private static final int BACK = 30;

  /**
   * 填充字符串至指定长度
   * 
   * @param arg0 原始字符串
   * @param arg1 填充后长度
   * @param arg2 填充位置（前或后，参照本类常量）
   * @param arg3 填充字符
   * @return 填充后字符串
   */
  private static String fill(String arg0, int arg1, int arg2, String arg3) throws Exception {
    // 验证数据
    if (arg1 < 1) {
      throw new Exception("填充长度不能小于1！");
    }
    if (arg2 != FRONT && arg2 != BACK) {
      throw new Exception("该填充位置不存在！");
    }
    if (arg3 == null || "".equals(arg3)) {
      throw new Exception("填充字符不能为空！");
    }
    if (arg3.length() != 1) {
      throw new Exception("填充字符长度不得大于1！");
    }
    /*
     * 填充 1、若待填充字符串为NULL，则返回长度为arg1，且各字符为arg3的字符串
     * 2、若代填充字符串长度大于等于填充长度，则返回待填充字符串本身
     */
    String strResult = arg0 == null ? "" : arg0;
    strResult = strResult.trim();
    if (strResult.length() >= arg1) {
      return strResult;
    }
    // 填充长度
    int lenFill = arg1 - strResult.length();
    if (arg2 == 10) {
      // 前部填充
      for (int i = 0; i < lenFill; i++) {
        strResult = arg3 + strResult;
      }
    } else {
      // 后部填充
      for (int i = 0; i < lenFill; i++) {
        strResult += arg3;
      }
    }
    return strResult;
  }
  
  /**
   * 前填充<br>
   * source：字符串<br>
   * len：长度<br>
   * fillStr：填充字符<br>
   */
  public static String fillFront(String source, int len, String fillStr) throws Exception {
    return fill(source, len, FRONT, fillStr);
  }

  /**
   * 前填充<br>
   * source：字符串<br>
   * len：长度<br>
   * fillStr：填充字符<br>
   */
  public static String fillBack(String source, int len, String fillStr) throws Exception {
    return fill(source, len, BACK, fillStr);
  }

  public static void main(String[] args) throws Exception {
    System.out.println(StringUtils.fill("71002", 8, StringUtils.FRONT, "0"));
  }

}
